package com.rem.designPattern.designPrinciple.liskovSubstitution.improve;

/**
 * 设计模式七大原则--里氏替换
 * 子类中尽量不要重写父类的方法
 * 继承实际上让两个类耦合性增强了，在适当的情况下，可以通过聚合，组合，依赖 来解决问题
 * <p>
 * 需求：每个类有不同的计算方法，实现各个类的计算
 * <p>
 * 改进：将原有的A、B类都继承一个基类，然后B依赖A实现自己的方法
 *
 * @author Rem
 * @date 2022-11-12
 */
public class Liskov02 {
    public static void main(String[] args) {
        System.out.println("-----------a 正常运算------------");
        A a = new A();
        System.out.println("11-3=" + a.func1(11, 3));
        System.out.println("1-8=" + a.func1(1, 8));

        System.out.println("----------B继承A 实现A的所有方法后误操作-------------");
        B b = new B();
        //这里没有继承A的方法，所以实现的都是B类自己的方法
        System.out.println("fun1： 11+3= " + b.func1(11, 3));
        //求解两数之和与9相加
        System.out.println("11+3+9= " + b.func2(11, 3));

        //在B中使用A的方法
        System.out.println("在B中使用A的方法  11-3= " + b.func3(11, 3));
    }
}

/**
 * 更加基础的方法写到Base类中
 */
class Base {

}

class A extends Base {
    /**
     * 返回两个数的差
     *
     * @param num1
     * @param num2
     * @return
     */
    public int func1(int num1, int num2) {
        return num1 - num2;
    }
}

/**
 * 增加了一个新功能：完成两个数相加,然后和 9 求和
 */
class B extends Base {

    /**
     * 仍然想使用A的方法 改用聚合的方式
     *
     * @param a
     * @param b
     * @return
     */
    public int func3(int a, int b) {
        return new A().func1(a, b);
    }

    /**
     * 计算两个数之和
     *
     * @param a
     * @param b
     * @return
     */
    public int func1(int a, int b) {
        return a + b;
    }

    /**
     * 计算两个数之和后与9相加
     *
     * @param a
     * @param b
     * @return
     */
    public int func2(int a, int b) {
        return func1(a, b) + 9;
    }
}